package JUC.wn_syn_vlo;


/*

全局放哪？
 */

class T1 extends Thread{
    int[] x;
    T1(int[] x){
        this.x = x;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3000000; i++) {
            x[0]++;
            System.out.println(String.format("%s %s",Thread.currentThread().getName(),x[0]));
        }
    }
}
class T2 implements Runnable{
    int[] x;
    T2(int[] x){
        this.x = x;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3000000; i++) {
            x[0]++;
            System.out.println(String.format("%s %s",Thread.currentThread().getName(),x[0]));
        }
    }
}

public class i加加_vlo_syn_自 {
    /*
    这样实现 就不用构造函数了

    class 任意位置
    main独立 启动谁都可以 自己启动自己都可
    */
    static  int zz=0;
    class T11{}
    class T22{}

    public static void main(String[] args) throws Exception{
        int[] x = {0}; // main进程资源单位 共享 和匿名底层一样的


        T1 t1 = new T1(x);
        t1.start();
        Thread t2 = new Thread(new T2(x));
        t2.start(); // 是内存地址改 上来瞬间同时放入没事 无所谓


//        // 保证上面执行完
//        try {
//            Thread.sleep(5000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        t1.join();
        t2.join();
        /*
         相当于
         mian线程
         调用
            t1直接当锁.wait 释放

            但是我们需要知道的是，调用wait方法必须要获取锁，
            所以join方法是被synchronized修饰的，
            synchronized修饰在方法层面相当于synchronized(this),thi~
            执行完
            native c notify

            wait是释放锁 去执行 等唤醒 【 join只用到了唤醒 x 也用到锁了
            因为  synxxx{xxx.w} synxxx{xxx.n} 里面才能有wn

            notify

            w / nof
                syn有xxx就必用同xx
                syn加在方法上 就this.

         */
        System.out.println(x[0]); // 不用最后 sout Thre里 format x[0]就是
    }
}